Method, manufacture, and apparatus for content protection using authentication data

ABSTRACT

A method, apparatus, and manufacture for content protection using authentication data. A client media player is employed to determine whether media content is protected. The client media player includes an application, and further includes a media engine that is a distinct program from the application. Upon determining that the media content is protected, the application is employed to get a key and/or a license for the protected media content such that authentication data is employed to authorize the client. The authentication data includes at least one of a software token or a cookie. The application is employed to instruct the media engine to play the media content. The key and/or the license is sent from the application to the media engine.

CROSS-REFERENCE TO RELATED APPLICATION

This application is a utility patent application based on previously filed U.S. Provisional Patent Application Ser. No. 61/569,755 filed on Dec. 12, 2011, the benefit of which is hereby claimed under 35 U.S.C. §119(e) and incorporated herein by reference.

TECHNICAL FIELD

The invention is related to computer software, and in particular, but not exclusively, to a method, manufacture, and apparatus for providing content protection in which authorization for use of the content protection is accomplished with authentication data such as a software token or domain cookie.

BACKGROUND

Today, HTML5 media tags, such as <video> and <audio> tags are available to provide content providers with a simple way to deliver their audio and video content onto the web, and have it play on any web browser or browser-based device. The underlying functionality of the HTML media tags are referred to as HTML media elements. The <video> and <audio> tags enable an ecosystem where plugins are no longer required to play this content and end users have consistent access to it across their web-enabled devices. To date, content protection mechanisms to enable use of content that its owner wants to protect from unauthorized use are not supported in the context of HTML media tags.

BRIEF DESCRIPTION OF THE DRAWINGS

Non-limiting and non-exhaustive embodiments of the present invention are described with reference to the following drawings, in which:

FIG. 1 illustrates a system diagram of one embodiment of an environment in which the embodiments of the invention may be practiced;

FIG. 2 shows one embodiment of a client device that may be included in the system of FIG. 1;

FIG. 3 illustrates one embodiment of a network device that may be included in the system of FIG. 1;

FIG. 4 shows a flowchart of an embodiment of a process;

FIG. 5 illustrates a flowchart of an embodiment of the process of FIG. 4;

FIG. 6 shows a system that may be employed as an embodiment of the system of FIG. 1; and

FIG. 7 illustrates a flowchart of an embodiment of the process of FIG. 5, in accordance with aspects of the invention.

DETAILED DESCRIPTION

Various embodiments of the present invention will be described in detail with reference to the drawings, where like reference numerals represent like parts and assemblies throughout the several views. Reference to various embodiments does not limit the scope of the invention, which is limited only by the scope of the claims attached hereto. Additionally, any examples set forth in this specification are not intended to be limiting and merely set forth some of the many possible embodiments for the claimed invention.

Throughout the specification and claims, the following terms take at least the meanings explicitly associated herein, unless the context dictates otherwise. The meanings identified below do not necessarily limit the terms, but merely provide illustrative examples for the terms. The meaning of “a,” “an,” and “the” includes plural reference, and the meaning of “in” includes “in” and “on.” The phrase “in one embodiment,” as used herein does not necessarily refer to the same embodiment, although it may. Similarly, the phrase “in some embodiments,” as used herein, when used multiple times, does not necessarily refer to the same embodiments, although it may. As used herein, the term “or” is an inclusive “or” operator, and is equivalent to the term “and/or,” unless the context clearly dictates otherwise. The term “based, in part, on”, “based, at least in part, on”, or “based on” is not exclusive and allows for being based on additional factors not described, unless the context clearly dictates otherwise. The term “coupled” means at least either a direct electrical connection between the items connected, or an indirect connection through one or more passive or active intermediary devices. The term “signal” means at least one current, voltage, charge, temperature, data, or other signal.

Briefly stated, the invention is related to a method, apparatus, and manufacture for content protection using authentication data. A client media player is employed to determine whether media content is protected. The client media player includes an application, and further includes a media engine that is a distinct program from the application. Upon determining that the media content is protected, the application is employed to get a key and/or a license for the protected media content such that authentication data is employed to authorize the client. The authentication data includes at least one of a software token or a cookie. The application is employed to instruct the media engine to play the media content. The key and/or the license is sent from the application to the media engine.

The acts discussed above do not proceed in the exact order discussed above in every embodiment. In some of these embodiments, the application determines that the media content is protected (or the server may determine that the media content is encrypted and communicate this to the application), the application then gets the key and/or license such that authentication data is employed to authorize the client, and then the application instructs the media engine to initiate playback and the application also sends the key and/or license to the media engine.

In other embodiments, the application instructs the media engine to initiate playback, and the media engine may then make a determination as to whether or not the media content is protected. The media engine then provides an indication to the application that the media content is protected. In response, the application gets the key and/or license such that authentication data is employed to authorize the client, and the application then sends the key and/or license to the media engine.

Illustrative Operating Environment

FIG. 1 shows components of one embodiment of an environment in which the invention may be practiced. Not all the components may be required to practice the invention, and variations in the arrangement and type of the components may be made without departing from the spirit or scope of the invention. As shown, system 100 of FIG. 1 includes local area networks (“LANs”) wide area networks (“WANs”)-(network) 111, wireless network 110, client devices 101-104, and server device 108.

One embodiment of client devices 101-104 is described in more detail below in conjunction with FIG. 2. Generally, however, client devices 102-104 may include virtually any portable computing device capable of receiving and sending a message over a network, such as wireless network 110, or the like. Client devices 102-104 may also be described generally as client devices that are configured to be portable. Thus, client devices 102-104 may include virtually any portable computing device capable of connecting to another computing device and receiving information. Such devices include portable devices such as, cellular telephones, smart phones, display pagers, radio frequency (RF) devices, infrared (IR) devices, Personal Digital Assistants (PDAs), handheld computers, laptop computers, wearable computers, tablet computers, integrated devices combining one or more of the preceding devices, and the like. As such, client devices 102-104 typically range widely in terms of capabilities and features. For example, a cell phone may have a numeric keypad and a few lines of monochrome LCD display on which only text may be displayed. In another example, a web-enabled mobile device may have a touch sensitive screen, a stylus, and several lines of color LCD display in which both text and graphics may be displayed.

Client device 101 may include virtually any computing device capable of communicating over a network to send and receive information. The set of such devices may include devices that typically connect using a wired or wireless communications medium such as personal computers, multiprocessor systems, microprocessor-based or programmable consumer electronics, network PCs, or the like. In one embodiment, at least some of client devices 102-104 may operate over wired and/or wireless network.

A web-enabled client device may include a browser application that is configured to receive and to send web pages, web-based messages, and the like. The browser application may be configured to receive and display graphics, text, multimedia, and the like, employing virtually any web-based language, including a wireless application protocol messages (WAP), and the like. In one embodiment, the browser application is enabled to employ Handheld Device Markup Language (HDML), Wireless Markup Language (WML), WMLScript, JavaScript, Standard Generalized Markup Language (SMGL), HyperText Markup Language (HTML), eXtensible Markup Language (XML), and the like, to display and send a message. In one embodiment, a user of the client device may employ the browser application to perform various activities over a network (online). However, another application may also be used to perform various online activities.

Wireless network 110 is configured to couple client devices 102-104 and its components with network 111. Wireless network 110 contains at least one Access Point (not shown in FIG. 1). Wireless network 110 may include any of a variety of wireless sub-networks that may further overlay stand-alone ad-hoc networks, and the like. Such sub-networks may include mesh networks, Wireless LAN (WLAN) networks, cellular networks, and the like.

Wireless network 110 may further include an autonomous system of terminals, gateways, routers, and the like connected by wireless radio links, and the like. These connectors may be configured to move freely and randomly and organize themselves arbitrarily, such that the topology of wireless network 110 may change rapidly.

Wireless network 110 may further employ a plurality of access technologies including 2^(nd) (2G), 3^(rd) (3G), 4^(th) (4G), 5^(th) (5G) generation radio access for cellular systems, WLAN, Wireless Router (WR) mesh, and the like. Access technologies such as 2G, 3G, 4G, and future access networks may enable wide area coverage for mobile devices, such as client devices 102-104 with various degrees of mobility. For example, wireless network 110 may enable a radio connection through a radio network access such as Global System for Mobil communication (GSM), General Packet Radio Services (GPRS), Enhanced Data GSM Environment (EDGE), Wideband Code Division Multiple Access (WCDMA), and the like.

Network 111 is configured to couple network devices with other computing devices, and through wireless network 110 to client devices 102-104. Network 111 is enabled to employ any form of computer readable media for communicating information from one electronic device to another. Also, network 111 can include the Internet in addition to local area networks (LANs), wide area networks (WANs), direct connections, such as through a universal serial bus (USB) port, other forms of computer-readable media, or any combination thereof. On an interconnected set of LANs, including those based on differing architectures and protocols, a router acts as a link between LANs, enabling messages to be sent from one to another. In addition, communication links within LANs typically include twisted wire pair or coaxial cable, while communication links between networks may utilize analog telephone lines, full or fractional dedicated digital lines including T1, T2, T3, and T4, Integrated Services Digital Networks (ISDNs), Digital Subscriber Lines (DSLs), wireless links including satellite links, or other communications links known to those skilled in the art. Furthermore, remote computers and other related electronic devices could be remotely connected to either LANs or WANs via a modem and temporary telephone link. In essence, network 111 includes any communication method by which information may travel between computing devices.

Additionally, communication media typically embodies computer-readable instructions, data structures, program modules, or other transport mechanism and includes any information delivery media. By way of example, communication media includes wired media such as twisted pair, coaxial cable, fiber optics, wave guides, and other wired media and wireless media such as acoustic, RF, infrared, and other wireless media.

Server device 108 is a network device. Devices that may operate as server 108 include various network devices, including, but not limited to personal computers, desktop computers, multiprocessor systems, microprocessor-based or programmable consumer electronics, network PCs, server devices, network appliances, and the like. It should be noted that while various devices are shown in a particular quantity, for example, server 108 is shown as one device, in various embodiments there may a different quantity of such devices, such two or more servers. There may even be two or more separate networks of servers. Thus, the invention is not to be construed as being limited to a single environment and other configurations, and architectures are also envisaged.

Illustrative Client Device

FIG. 2 shows one embodiment of client device 200 that may be included in a system implementing the invention. Client device 200 may include many more or less components than those shown in FIG. 2. However, the components shown are sufficient to disclose an illustrative embodiment for practicing the present invention. Client device 200 may represent, for example, one embodiment of at least one of client devices 101-104 of FIG. 1 (and, accordingly, may include virtually any type of client device).

As shown in the figure, client device 200 includes a processing unit (CPU) 222 in communication with a mass memory 230 via a bus 224. Client device 200 also includes a power supply 226, one or more network interfaces 250, an audio interface 252, a display 254, a keypad 256, an illuminator 258, an input/output interface 260, a haptic interface 262, and an optional global positioning systems (GPS) receiver 264. Power supply 226 provides power to client device 200. A rechargeable or non-rechargeable battery may be used to provide power. The power may also be provided by an external power source, such as an AC adapter or a powered docking cradle that supplements and/or recharges a battery.

Client device 200 may optionally communicate with a base station (not shown), or directly with another computing device. Network interface 250 includes circuitry for coupling client device 200 to one or more networks, and is constructed for use with one or more communication protocols and technologies including, but not limited to, global system for mobile communication (GSM), code division multiple access (CDMA), time division multiple access (TDMA), user datagram protocol (UDP), transmission control protocol/Internet protocol (TCP/IP), SMS, general packet radio service (GPRS), WAP, ultra wide band (UWB), IEEE 802.16 Worldwide Interoperability for Microwave Access (WiMax), SIP/RTP, or any of a variety of other wired or wireless communication protocols, including Wi-Fi, Ethernet, and/or the like. Network interface 250 is sometimes known as a transceiver, transceiving device, or network interface card (NIC).

Audio interface 252 is arranged to produce and receive audio signals such as the sound of a human voice. For example, audio interface 252 may be coupled to a speaker and microphone (not shown) to enable telecommunication with others and/or generate an audio acknowledgement for some action. Display 254 may be a liquid crystal display (LCD), gas plasma, light emitting diode (LED), or any other type of display used with a computing device. Display 254 may also include a touch sensitive screen arranged to receive input from an object such as a stylus or a digit from a human hand.

Keypad 256 may comprise any input device arranged to receive input from a user. For example, keypad 256 may include a push button numeric dial, or a keyboard. Keypad 256 may also include command buttons that are associated with selecting and sending images. Illuminator 258 may provide a status indication and/or provide light. Illuminator 258 may remain active for specific periods of time or in response to events. For example, when illuminator 258 is active, it may backlight the buttons on keypad 256 and stay on while the client device is powered. Also, illuminator 258 may backlight these buttons in various patterns when particular actions are performed, such as dialing another client device. Illuminator 258 may also cause light sources positioned within a transparent or translucent case of the client device to illuminate in response to actions.

Client device 200 also comprises input/output interface 260 for communicating with external devices, such as a headset, or other input or output devices not shown in FIG. 2. Input/output interface 260 can utilize one or more communication technologies, such as USB, infrared, Bluetooth™, or the like. Haptic interface 262 is arranged to provide tactile feedback to a user of the client device. For example, the haptic interface may be employed to vibrate client device 200 in a particular way when another user of a computing device is calling.

Mass memory 230 includes a RAM 232, a ROM 234, and other storage means. Mass memory 230 illustrates an example of computer readable storage media (devices) for storage of information such as computer readable instructions, data structures, program modules or other data. Mass memory 230 stores a basic input/output system (“BIOS”) 240 for controlling low-level operation of client device 200. The mass memory also stores an operating system 241 for controlling the operation of client device 200. It will be appreciated that this component may include a general-purpose operating system such as a version of UNIX, or LINUX™, or a specialized client communication operating system such as Windows Mobile™, or the Symbian® operating system. The operating system may include, or interface with a Java virtual machine module that enables control of hardware components and/or operating system operations via Java application programs.

Memory 230 further includes one or more data storage 248, which can be utilized by client device 200 to store, among other things, applications 242 and/or other data. Applications 242 may include computer executable instructions which, when executed by client device 200, perform actions. Other examples of application programs include calendars, search programs, email clients, IM applications, SMS applications, VOIP applications, contact managers, task managers, transcoders, database programs, word processing programs, security applications, spreadsheet programs, games, search programs, and so forth. In some embodiments, applications 242 may include a browser, a media stack for the browser, a content decryption module for decrypting media content for the media stack, and an application running on the browser such as a web application.

Various embodiments of client device 200 may include applications 242 to perform various functions discussed herein and/or discussed with regard to some of the steps as illustrated in the flowcharts shown below. These stored applications are processor-executable code encoded on a processor-readable medium, which, when executed by CPU 222, enable actions to performed in accordance with the processor-executable code. In some embodiments, the applications 242 such as a web application for the browser and a media stack for the browser may perform steps such as those illustrated in the flowcharts below.

Although the discussion of various embodiments above has described the performance of actions implemented in software, for example by means of processor-executable code encoded on a processor-readable medium, which, when executed by CPU 222, enable actions to performed in accordance with the processor-executable code, in various embodiments, actions, may in some embodiments, rather than being performed only by executed software, may instead be performed based on hardware only, or by a combination of hardware and software.

Illustrative Network Device

FIG. 3 shows one embodiment of a network device 300, according to one embodiment of the invention. Network device 300 may include many more or less components than those shown. The components shown, however, are sufficient to disclose an illustrative embodiment for practicing the invention. Network device 300 may represent, for example, server 108 of FIG. 1.

Network device 300 may include processing unit 312, video display adapter 314, and a mass memory, all in communication with each other via bus 322. The mass memory generally includes RAM 316, ROM 332, and one or more permanent mass storage devices, such as hard disk drive 328, tape drive, optical drive, and/or floppy disk drive. The mass memory may store operating system 320 for controlling the operation of network device 300. Any general-purpose operating system may be employed. Basic input/output system (“BIOS”) 318 may also be provided for controlling the low-level operation of network device 300. As illustrated in FIG. 3, network device 300 also can communicate with the Internet, or some other communications network, via network interface unit 310, which may be constructed for use with various communication protocols including the TCP/IP protocol. Network interface unit 310 is sometimes known as a transceiver, transceiving device, or network interface card (NIC).

The mass memory as described above illustrates another type of computer-readable/processor-readable media, namely computer-readable storage media. Computer-readable storage media (devices) may include volatile, nonvolatile, removable, and non-removable media implemented in any method or technology for storage of information, such as computer readable instructions, data structures, program modules, or other data. Examples of computer-readable storage media include RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other physical medium which can be used to store the desired information and which can be accessed by a computing device.

Data stores 354 may include a database, text, spreadsheet, folder, file, or the like. Data stores 354 may further include program code, data, algorithms, and the like, for use by a processor, such as central processing unit (CPU) 312 to execute and perform actions. In one embodiment, at least some of data and/or instructions stored in data stores 354 might also be stored on another device of network device 300, including, but not limited to cd-rom/dvd-rom 326, hard disk drive 328, or other computer-readable storage device resident on network device 300 or accessible by network device 300 over, for example, network interface unit 310.

The mass memory also stores program code and data. One or more applications 350 may be loaded into mass memory and run on operating system 320. Examples of application programs may include transcoders, schedulers, calendars, database programs, word processing programs, Hypertext Transfer Protocol (HTTP) programs, customizable user interface programs, IPSec applications, encryption programs, authentication programs, security programs, SMS message servers, IM message servers, email servers, account managers, and so forth. In some embodiments, as discussed in greater detail below, application 350 may include applications for providing a content authorization service, and may provide a key and/or license to an authorized requesting client application, such that authentication data is employed to authorize the client.

Generalized Operation

The operation of certain aspects of the invention will now be described with respect to FIG. 4.

FIG. 4 illustrates a flow chart of an embodiment of process 470. After a start block, the process proceeds to decision block 475, where a client media player makes a determination as to whether media content is protected. For example, such “protection” may include encryption in some embodiments. The client media player includes an application, and further includes a media engine that is a distinct program from the application. If the media content is not protected, the process proceeds to a return block, where other processing is resumed.

However, if the content is protected, the process then moves to block 477, where the application is employed to get a key and/or a license for the protected media content such that authentication data is employed to authorize the client. For example, the authentication data may include a software token and/or a cookie. The process then advances to block 473, where the application is employed to instruct the media engine to play the media content.

The process then proceeds to block 478, where the key and/or the license is sent from the application to the media engine. The process then moves to the return block.

The acts discussed above do not proceed in the exact order discussed above in every embodiment. In some embodiments, the act may happen in the order shown. In some of these embodiments, the application determines at decision block 475 that the media content is protected (or the server may determine that the media content is encrypted and communicate this to the application), the application then gets the key and/or license such that authentication data is employed to authorize the client at block 477, and then the application instructs the media engine to initiate playback and send the key and/or license to the media engine (with block 473 and 478 happening in either order or at the same time).

In other embodiments, the act at block 473 may happen prior to decision block 475. For example, in some embodiments, the application instructs the media engine to initiate playback (block 473). The media engine may then make a determination as to whether or not the media content is protected at decision block 475. The media engine then provides an indication to the application that the media content is protected. In response, the application gets the key and/or license such that authentication data is employed to authorize the client at block 477. The application then sends the key and/or license to the media engine at block 478.

The media engine performs decoding of media content. In some embodiments, the media engine is a set of connected media processing and rendering modules used for converting digital media data into human-perceptible representations (e.g., moving pictures and/or sound). The media engine performs functions such as de-multiplexing, decryption, and rendering in some embodiments. In some embodiments, the media engine has substantially no other logic, but just renders what it is fed, and can therefore be used for all types of media playback applications. In some embodiments, certain functions such as decryption are not performed directly by the media engine itself, but by a separate module under the control of the media engine.

The application instructs the media engine to playback media content. In some embodiments, the application includes computer-executable code that implements substantially all logic required to play back media in a particular context, includes user interface logic, subtitle control information, control of the acquisition of content control data, and the like, but not processing and rendering. The processing, decryption, and rendering is instead performed by the media engine (with, in some embodiments, some functions performed by separate modules under the control of the media engine). In some embodiments, the rendering is performed by a part of the browser other than the media engine. Together, the media engine and the application both reside in the client and operate as a client media player. The media engine and the application are distinct programs or binaries or libraries, etc., where the media engine can be re-used. The media engine is part of an application framework, together with other modules that implement user input, graphics output, network I/O etc. The application framework exposes standard abstract interfaces for these functions to the application.

This particular separation between media engine (as part of the application framework) and application is useful because the media engine implementation is typically specific to the type of computer hardware platform it executes on, and therefore is implemented in a way that is strongly connected to the operating system. The same holds for user input, graphics output, network I/O, etc. In some embodiments, the media engine is specific to a particular type of content protection. The application, however, can be the same across many different computer platforms when the underlying application framework abstracts access to user input, network, graphics, media engine etc. In some embodiments, the media content is protected by encryption, and the license and/or key is employed to decrypt the encrypted media content. In some embodiments, the media content is protected by a license.

The decryption function in the media engine is initialized by the key/license when the key/license is provided to the media engine. A content encryption key may be generated employing any of a number of encryption/decryption symmetric mechanisms, including, but not limited to Advanced Encryption Standard (AES), RSA, RC6, IDEA, DES, RC2, RC5, Skipjack, and any other symmetric encryption algorithm. Moreover, such encryption algorithms may use, where appropriate, cipher block chaining mode, cipher feedback mode, CBC cipher text stealing (CTS), CFB, OFB, counter mode, and/or any other block mode. In some embodiments, content encryption keys are generated employing an at least 128 bit AES encryption/decryption algorithm. However, content encryption key generation is not limited to symmetric key mechanisms, and asymmetric key mechanisms may also be employed without departing from the scope of the present invention. Typically, where the content encryption key is a symmetric encryption key, such content encryption keys are also referred to as decryption keys, as the same key may be used to both encrypt and to decrypt the content.

In block 477, the application may get the key and/or license in a number of different ways in different embodiments. In some embodiments, the application gets the key and/or the license via communication with a server. In some embodiments, the key and/or license may be found locally or on a local network. In some embodiments, the key and/or license is acquired in accordance with a digital right management (DRM) scheme, or other content protection system. For example, in some embodiments, a commercial DRM may be employed. In other embodiments, the key and/or license could be stored in the application. The application is configurable to different types of content protection through the same framework. The application defines a protocol or process and standardizes the interfaces so that the process could be configured to work with any of a variety of like underlying sort of technologies, but the interface is the same regardless of the content protection system used.

In block 477, the application may get the key in communication with a server or the like in some embodiments, but the key/license acquisition process is performed by the application; the media engine is not involved in the key/license acquisition process at all, except that the media engine may indicate to the application that the key/license is needed, the application may request a key/license request message from the media engine, the media engine may indicate that type(s) of content protection system(s) the media engine supports, and the application may provide the key/license to the media engine once the key/license has been acquired.

Since the key/license acquisition occurs not in the media engine but in the application, the application has control over the error handling for the key/license acquisition, and the application can handle error conditions and the like.

The process of acquiring a key and/or license can be accomplished multiple times during a single playback session, e.g., for key rotation.

The key/license should only be provided to authorized users. As discussed above, the key/license acquisition/retrieval may be accomplished in a number of different ways in different embodiments, including a DRM scheme in some embodiments. Regardless of which key/license acquisition/retrieval method is being used in the particular embodiment, the key/license acquisition/retrieval authorizes users based on authentication data. The authentication data may include a software token, domain cookie (e.g., browser cookie), and/or the like.

For example, in some embodiments, the authentication data includes a web authentication token. In some embodiments, the client browser receives and stores a web authentication token as a result of logging into a website prior to attempting to play the protected media. In essence, the user is already an authorized user as a result of the previous authentication. In some embodiments, the web authentication token may be obtained using standard web authentication credentials. The web authentication token is effectively a representation of the fact that the user is already authorized. Accordingly, the web authentication token may be used during the key/license acquisition/retrieval rather than requiring yet another authorization beyond the authentication required to obtain the web authentication token in the first place. Instead of requiring a new authentication, an existing authentication is used to authorize the user, such as a web authentication token or domain cookie or the like.

In some embodiments, the authentication data (including, e.g., a web authentication token, domain cookie, and/or the like) may be combined with one or more messages in the content protection system messages (e.g., in some embodiments, the request for a key/license sent from the application to a server). In various embodiments, the user authentication data may be provided along with the message yet be separate from the message, and in other embodiments, the user authentication data may be combined into the message.

In some of these embodiments, the authentication data is appended to the message (e.g., the key/license request sent from the application to the server), yet separate from the message, where the authentication data is wrapped, signed, and/or encrypted.

In some of these embodiments, rather than providing the authentication data with the message but separately from the message, the authentication data may be combined into the message. In some embodiments, the application provides the authentication to the DRM client (e.g., via generateKeyRequest( ) as discussed below), which integrates it into the message, where the message is encrypted/signed.

In these embodiments, the license server verifies that the user has permission/access by verifying the authentication data before providing a key/license. The license server may extract the authentication data from the message in some embodiments so that the license server can use the extracted authentication data to verify that the user is authorized.

In other embodiments, the key/license acquisition/retrieval process does not use the authentication data to acquire/retrieve the key/license at all, but the acquired/retrieved key/license is encrypted in such a way that the key/license can only be decrypted using at least part of the authentication data. In this way, only authorized users can actually make use of the license/key to decrypt the protected media content. Requiring the encrypted key to be decrypted using the authentication data may be useful, for example, in embodiments that do not use a DRM client.

In some embodiments, the user authentication token (or other user authentication data) may store something from the DRM client, such as a signature from the DRM client, which may assist in preventing replay attacks.

As previously discussed, the key/license acquisition/retrieval process is controlled by the application rather than the media engine. In some embodiments, based on the application, the authentication data is stored, and the authentication data is not provided to the media engine. Inn some embodiments, the authentication data remains with the application, and may, for example, be provided to the server in some embodiments, but is not provided to the media engine. In other embodiments, the authentication data may be provided to the media engine to be encrypted as part of the key/license request message. In some embodiments in which the encrypted key/license is decrypted with part of the authentication data, the decryption of key may be performed in the application, whereas the decryption of the media content with the decrypted key is performed under the control of the media engine. In other embodiments, part of the authorization data may be provided to the media engine and the media engine may perform decryption of the key.

In some embodiments, process 470 may be employed to play encrypted media content accessed via an HTML media element, in HTML5 or future versions of HTML that employ HTML media elements such as <media>, <video>, <audio>, and future HTML media elements. In these embodiments, the application may be a web application running in browser, and the media engine may be a media stack of the browser. One such embodiment of process 470 is illustrated in FIG. 5.

FIG. 5 illustrates a flowchart of an embodiment of process 570, which may be employed as an embodiment of process 470 in which the application is a web application running in a browser, the media content is encrypted media content accessed via an HTML media element, and the media engine is a media stack of the browser. The web application may include JavaScript (or a scripting language other than JavaScript) and HTML.

After a start block, the process proceeds to block 571, where a client browser loads a web application. The process then moves to block 577, where the web application is employed to get a key and/or a license for the encrypted media content such that authentication data is employed to authorize the client, and where the encrypted media content is accessed via an HTML media element. The key and/or license may be acquired or retrieved in a variety of different ways in different embodiments. In some embodiments, a license is used to establish the content key in the media stack in content protection mechanisms where the key is not transmitted in the clear, and the key is extracted from or derived from the license data.

The process then advances to block 573, where the web application is employed to instruct a media stack of the client browser to play the encrypted media content. In some embodiments, the web application may contain an autoplay attribute, in which case the browser parses the web application, discovers the autoplay attribute, and causes the media stack to autoplay the media content. In other embodiments, there is no autoplay attribute for the media content, and the web application instructs the media stack when to play media content. The media stack is instructed to play the media content in a time and manner that is in accordance with the web application. For example, in some embodiments, the web application instructs the media stack to play the media content when a “play” button is pressed by the user.

The process then moves to block 578, where the key and/or the license is sent from the web application to the media stack. The process then proceeds to a return block, where other processing is resumed.

The acts discussed above do not proceed in the exact order discussed above in every embodiment. In some embodiments, the act may happen in the order shown. In some of these embodiments, the application then gets the key and/or license such that authentication data is employed to authorize the client at block 577, and then the application instructs the media stack to initiate playback and send the key and/or license to the media stack (with block 573 and 578 happening in either order or at the same time).

In other embodiments, the act at block 573 may happen prior to block 577. For example, in some embodiments, the application instructs the media stack to initiate playback (block 573). The media stack may then discover that the media content is encrypted. The media stack then provides an indication to the application that the media content is protected. In response, the application gets the key and/or license such that authentication data is employed to authorize the client at block 577. The application then sends the key and/or license to the media stack at block 578.

FIG. 6 shows system 600, which may be employed as an embodiment of system 100 of FIG. 1. System 600 includes license server 608, web server 609, content delivery network (CDN) 607, and client device 601. License server 608, web server 609, and CDN 607 may each, for example, be one or more server device such as server device 108 of FIG. 1 and/or network device 300 of FIG. 3. Client device 601 may be, for example, an embodiment of client device 101-104 of FIG. 1 and/or client device 200 of FIG. 2.

Client device 601 includes application 644, content decryption module (CDM) 649, platform 643, and browser 645. Browser 645 includes media stack 646 and network stack (Net) 657.

Application 644 is a media playback control application, such as the application discussed with regard to FIG. 4 and the web application discussed with regard to FIG. 5.

As discussed above, media stack 646 performs decoding of media content. In some embodiments, media stack 646 is a set of connected media processing and rendering modules used for converting digital media data into human-perceptible representations (e.g., moving pictures and/or sound). The media stack performs functions such as de-multiplexing and rendering in some embodiments. In some embodiments, the media stack has substantially no other logic, but just renders what it is fed, and can therefore be used for all types of media playback applications in an interchangeable fashion.

Application 644 instructs media stack 646 to playback media content. In some embodiments, application 644 includes computer-executable code that implements substantially all of the logic required to play back media in a particular context, including user interface logic, subtitle control information, control of the acquisition of keys, and/or the like, but not processing and rendering. The processing and rendering is instead performed by media stack 646. In some embodiments, the rendering is performed by a part of browser 645 other than media stack 646. Together, media stack 646 and application 644 both reside in client device 601 and operate as a client media player. Media stack 646 and application 644 are distinct programs or binaries or libraries, etc., where media stack 646 can be re-used. As discussed above, application 644 may be a web application for playback of HTML media elements identified in HTML5 by HTML media tags such as <media>, <video>, and <audio>, where the web application includes JavaScript (or a scripting language other than JavaScript) and HTML.

CDM 649 performs decryption of media content in communication with media stack 646. In some embodiments, CDM 649 may use or defer to the capabilities of platform 643 of client device 601. In some embodiments, CDM 649 may be integrated with the media stack 646. In other embodiments, CDM 649 may be integrated with the platform 643.

In some embodiments, when application 644 acquires a license, it does so in communication with one or more servers. In some embodiments, web server 608 may handle requests or send directly to license server 609. In some embodiments, application 644 may communicate directly with license server 609.

In some embodiments, media stack 646 may acquire media content specified by application 644 via network stack 647, where network stack 647 acquires the media content from CDN 607.

FIG. 7 illustrates a flowchart of an embodiment of process 770, which may be employed as an embodiment of process 570 of FIG. 5. After a start block, the process proceeds to block 771, where the client browser loads the web application. The process then moves to block 772, where the client browser discovers an HTML media tag (e.g., <video> or <audio>) pointing to media content.

The process then advances to block 773, where the web application instructs the media stack of the client browser to initiate playback of the media content. The process then proceeds to block 774, where the media stack starts to procure the media content that the media stack was instructed to play back (e.g., through file reading, or progressive or adaptive streaming).

The process then advances to decision block 775, where the media stack makes a determination as to whether or not the media content is encrypted. For example, in some embodiments, the determination at decision block 775 may be made through out-of-band information, e.g., in the streaming manifest. In other embodiments, the determination at decision block 775 may be made through information in the content data itself, e.g., flags or headers. The actual mechanism of detection may be dependent on the media stack or content type.

If the content is encrypted, the process proceeds to block 776, where the media stack fires an event to the web application, where the event indicates that a key and/or license is needed to begin or continue playback of the media content. The process then moves to block 777, where the web application gets the key and/or license such that authentication data is employed to authorize the client. As discussed in greater detail above and below, the web application may get the key and/or license in a variety of different ways in different embodiments. For example, in some embodiments, the application acquires the key and/or the license via communication with one or more servers. In other embodiments, the key and/or license could be stored in the application. The process then advances to block 778, where the web application sends data (including the key and/or license) to the media stack.

The process then proceeds to block 779, where the media stack receives and verifies the data. The process then proceeds to block 781, where the media content is decrypted (if the content is encrypted), and decoded. The media stack decodes the media content. In some embodiments, the media content is first decrypted then decoded, and in other embodiments, the media content is first decoded then decrypted. In some embodiments, there is a separate decrypting module (e.g., CDM 649 of FIG. 6) that is employed to do the decryption. In some of these embodiments, the media stack may provide the encrypted media and the key and/or license to the decryption module, and the decryption module may decrypt the media and send the decrypted media content back to the media stack.

The process then advances to block 782, where the media content is rendered. In some embodiments, the media stack renders media content. In other embodiments, another part of the browser renders the media content. The processing then proceeds to a return block, where other processing is performed.

At decision block 775, if the media content is not encrypted, the process moves to block 781, where the media content is decoded.

Many variations to the exact process flow illustrated in FIG. 7 are within the scope and spirit of the invention. For example, in some embodiments, the web application may determine that the media is encrypted. Accordingly, rather than the web application instructing the media stack to initiate playback right away, in this case the web application can instead get the key and/or license, and after the web application gets the key and/or license, the web application can instruct the media stack to initiate playback along with sending the media stack the data that includes the key and/or license. In some embodiments, the media tags may specify that the media is encrypted.

In some embodiments, such as a key rotation scheme, the media stack can fire an event each time a new key is needed, and the application can provide the new key to the media stack.

Process 770 may be applied to local content, to content that is downloaded and then played, and/or to streaming content. Process 770 is not specific to any particular form of content protection, but may be applied to various forms of DRM and other forms of content protection in different embodiments. Process 770 provides a framework that is independent of and orthogonal to the particular form of content protection being used and other components of the video playback such as the content fetching mechanism, the content format, and its decoding and rendering mechanism, and supports a wide range of media containers and codecs. However, in each case, authentication data is employed to authorize the client. Process 770 can support a wide range of control system types, including traditional DRM systems, conditional access systems, simple key establishment without the need for DRM servers, and key distribution systems based on DRM systems using only a small subset of their typical functionality for streaming media.

In some embodiments, process 770 may be used for viewing commercial content, including commercial content protected by a content protection mechanism such as DRM, where the commercial content may include movies or the like. The media may be accessed via a webpage employing HTML5, or a future version of HTML that also supports media tags, where the media content is accessed in an HTML media tag such as <video> or <audio>. The media content, which is protected by some sort of content protection, such as encryption, DRM, and/or the like, can be accessed in a browser with an HTML media tag, with the media accessible, controllable, and configurable by the web application, where the media content can be streamed to the browser, downloaded, provided by the application, or local. The web application provides application level flexibility to implement the authorization exchange, and all of the HTML5 security mechanisms may be used for network transactions.

Today, HTML5<video> and <audio> tags are available to provide content providers with a simple way to deliver their audio and video content once to the web, and have it play on any web browser or browser-based device. The <video> and <audio> tags enable an ecosystem where plugins are no longer required to play this content and end users have consistent access to it across their web-enabled devices. Process 770 enables content protection systems, including DRM, to be applied to audio and/or video content delivered via <video> and <audio> tags, enabling secure authorization for media playback within HTML5 and future versions of HTML that include HTML media tags. With process 770, there is no need to use a plugin to deliver the protected media content. Process 770 enables media playback with content control, while avoiding the unnecessary technology lock-in that comes with content control today (ranging from file formats to codecs to application stacks to even full execution environments), and makes content control systems largely interchangeable.

Process 770 allows for a wide range of content control systems (from password-derived to traditional DRM) because it does not expose any of the inner workings of such systems on top of providing the facilities for a basic challenge/response mechanism to establish a decryption key. Process 770 also gives the web application control over the authorization exchange to allow for flexibility in implementation, e.g. network transaction with a backend service which would use all applicable HTML5 security mechanisms, and/or that requires custom failure handling (e.g. retransmit intervals), and/or that is combined with other unrelated information to minimize the number of separate network roundtrips required. The web application controls the license/key exchange and can implement custom license management algorithms.

In some embodiments, one attribute (authorizationData) and one event (authorizationNeeded) is added to the HTML5 media elements, as follows. In some of these embodiments, the design adds one new attribute to media elements named authorizationData. The purpose of this attribute is to provide the content control module in the media stack with the necessary information to initialize itself and enable playback of the requested content (e.g., a decryption key). In some embodiments, authorizationData may be a method that provides the data to the media element. The attribute authorizationData and the event authorizationNeeded may have different names in different embodiments. For example, in FIG. 6, they are referred to as addKey( ) [as a called function rather than an attribute] and needkey, respectively.

The authorizationNeeded event fires when the media stack underneath the media element discovers the need for fresh authorization data to start or continue playback. This event is accompanied by one or more blobs of data generated by the media stack that is potentially opaque to the application. The format of the data may be dependent on the content control mechanism(s) in the media stack and/or content format.

The authorizationNeeded event is an embodiment of the event fired at block 776 of process 770. In some embodiments, the authorizationNeeded event also contains supplemental data that is specific to the content control mechanism and/or content. The supplemental data can be opaque to the application—it only needs to be understood by the entity that creates the license data, which could be a network service in some embodiments.

The application uses the information mentioned above to procure the required content control data (either through an application-specific mechanism or through a content-control-specific mechanism). In some embodiments, the authorization data is used by a server to verify whether the user should be allowed access when it is processing the license request. Client authorization is obtained through authentication data, where, for example, the authentication data was combined with the license request. The authorizationNeeded event can fire multiple times during a single playback session, e.g., for key rotation.

The acquired content control data is provided to the media element via the authorizationData attribute. Once the data is present and correctly verified by the media stack, playout starts. In order to avoid playout delays due to latencies incurred when acquiring content control data, existing preload mechanisms can be used.

In some embodiments, the authorizationNeeded event contains an array of the following tuple: type and data, where type is an identifier of content control mechanism, and data is a byte array containing contents dependent on content control mechanism to enable application to acquire authorization data. In some embodiments, the authorizationData attribute includes a byte array in which the contents are dependent on content control mechanism, which enables the media stack to play content, and/or content data format.

In one possible embodiment of an application of the authorization data acquisition mechanism, content is encrypted using a content key, and a secure key distribution system stores the key. In some embodiments, the media stack contains client code of this secure key distribution system (though a pluggable mechanism or platform capabilities in some embodiments), and the content provider runs a key distribution service as a counterpart.

In some of these embodiments, the content control system uses: a “challenge” data structure generated on the client and a “license” data structure generated on the server using the content key and the client public key. The “challenge” data structure typically contains information about the content to be played for retrieval of the correct key, and information about the client DRM module (client ID, client type, public key for encryption of the content key for transport).

In these embodiments, the media stack detects that the content is encrypted, and can be decrypted using the secure key distribution system's client module. The content key is acquired through a network transaction. Since the application has not yet set the authorizationData attribute of the media element to a valid “license” data structure, the media stack generates a “challenge” data structure and serializes it into a byte stream.

In these embodiments, the authorizationNeeded event gets the following two attributes: (1) type=(<string or numeric identifier for the secure key distribution system>); and (2) data=<challenge bytestream>, and fires.

In these embodiments, the application catches the event using a handler for this event. In the handler, the web application generates a request to the streaming service's license server, using an existing authentication mechanism (e.g., domain cookie) that was combined with the license request to the server to authorize the request on the server, and the opaque data generated by the media stack's content protection client module. In some embodiments, the content control mechanism may choose to invalidate the authorization data after a certain number of uses, therefore disallowing replay of previously issued authorization data, and in consequence enforcing a requirement of fresh authorization for each playback.

In these embodiments, if authorization based on the existing authentication mechanism is successful, the license server may use the content identification data in the “challenge” data structure to retrieve the content key for the content to be played from its database, and use the client key to generate a “license” data structure, which is handed back to the application in the response. The application installs the opaque license data into the authorizationData attribute of the media element, and playout starts after successful verification of the license data and extraction or derivation of the content key from the license data by the media stack. The content control client module is responsible for: the security of the decrypted content, the security of the content key, the security of the client module keys that can be used to decrypt license data, and secure disposal of the content key after playback has ended. In some embodiments, the opaque license data contains all of the necessary information to play all streams of the content in question that are authorized to the requesting user on the target device. For example, if different streams of some particular content are encrypted with different keys, the license contains all of the keys and the necessary information to associate it with the correct streams.

In some of these embodiments, the system can be extended to allow offline playback without changing the media stack implementation of the content control system, e.g. by retrieving the key and/or license from storage.

In these embodiments, a simple offline playback system allows the user to “pin” content to the client device while the device is connected. The content data (one embodiment thereof, e.g., at appropriate bitrate and quality for the target device) is downloaded from the server in its entirety and stored in local storage. The application uses a media element to initiate preload of playback for the content data in local storage, which triggers the authorization data retrieval mechanism. The authorization data is retrieved by the application as in the streaming use case, but not installed in the authorizationData attribute yet. It is cached in local storage until offline playback is initiated.

In these embodiments, if required for management of the stored authorization data, the content protection system can support the transmission of additional information on top of the opaque authorization data blob to the web application, e.g. content ID, expiration date etc., e.g. through the network protocol that also serves to transmit the authorizationData blob. This mechanism can be proprietary to the content protection system in some embodiments.

In these embodiments, when playback is initiated, the application retrieves the authorization data from its internal storage and installs it in the media element, allowing playout to proceed.

Returning to FIG. 6, as discussed above, the event authorizationNeeded and the attribute authorizationData are instead replaced by the event needkey and the function addKey( ) respectively. Application 644 may use Get Key to acquire a key from a server, which may in turn respond with an encrypted key via Key from the server to application 644. The key may be provided from application 644 to media stack 646 via addKey( ) and from media stack 646 to CDM 649 via SetKey.

In some embodiments, canPlayType( ) is extended to provide basic information about content control systems supported by the browser.

Media stack 646 may provide an encrypted frame for CDM 649 to decrypt via Decrypt Frame. CDM 649 then decrypts the encrypted frame, and provides the decrypted frame back to media stack 646 via Frame.

In some embodiments, a generateKeyRequest( ) function may be employed from Application 644 to media stack 646. A Key Request may be sent from media stack 646 to application 644 in response to the generateKeyRequest( ) function.

In some embodiments, the data passed to generateKeyRequest( ) includes user authentication data. In other embodiments, the user authentication data is added to the resulting message via wrapping, appending, or the like.

The above specification, examples, and data provide a description of the manufacture and use of the composition of the invention. Since many embodiments of the invention can be made without departing from the spirit and scope of the invention, the invention also resides in the claims hereinafter appended. 

What is claimed is:
 1. A method, comprising: receiving and storing a web authentication token as a result of logging into a website; subsequent to storing the web authentication token, employing a media stack that is part of a client browser to initiate playback of media content accessed via a hypertext markup language (HTML) media element; employing the media stack to determine whether the media content is protected; generating, responsive to a determination by the media stack that the media content is protected, a request message requesting a license for playback of the media content; combining the web authentication token into the generated request message by encrypting the web authentication token into the request message, the combining comprising: integrating the web authentication token into the generated request message; and digitally signing the request message having the integrated web authentication token; sending the request message with the encrypted web authentication token to a server; receiving the license for playback of the media content from the server in response to the request message; and sending the received license to the media stack.
 2. The method of claim 1, wherein the web authentication token includes web authentication credentials.
 3. The method of claim 1, wherein the web authentication token includes a domain cookie.
 4. The method of claim 1, wherein determining whether the media content is protected includes at least one of determining whether the media content is encrypted or determining whether the media content is protected by a license.
 5. The method of claim 1, further comprising: obtaining a decrypted content key from the license by performing decryption such that the decryption employs at least a portion of the web authentication token.
 6. The method of claim 1, further comprising: employing the server to extract the web authentication token from the generated request message; and employing the server to determine whether the user is authorized based on the extracted web authentication token.
 7. The method of claim 1, wherein the web authentication token includes authentication data used by the server to verify that a user is authorized to playback the media content.
 8. The method of claim 1, wherein the license for playback of the media content from the server comprises: receiving a decryption key for decrypting the media content.
 9. The method of claim 1, wherein the license for playback of the media content from the server comprises: receiving a decryption key for decrypting the media content.
 10. A client device, comprising: a memory component for storing data; and a processing component that is configured to execute the stored data to perform actions comprising: receiving and storing a web authentication token as a result of logging into a website; subsequent to storing the web authentication token, employing a media stack that is part of a client browser to initiate playback of media content accessed via a hypertext markup language (HTML) media element; employing the media stack to determine whether the media content is protected; generating, responsive to a determination by the media stack that the media content is protected, a request message requesting a license for playback of the media content; combining the web authentication token into the generated request message by encrypting the web authentication token into the request message, the combining comprising: integrating the web authentication token into the generated request message; and digitally signing the request message having the integrated web authentication token; sending the request message with the encrypted web authentication token to a server; receiving the license for playback of the media content from the server in response to the request message; and sending the received license to the media stack.
 11. The client device of claim 10, wherein the web authentication token includes a domain cookie.
 12. A manufacture, including a non-transitory processor-readable storage medium having processor-executable code encoded therein, which when executed by one or more processors, performs actions comprising: receiving and storing a web authentication token as a result of logging into a website; subsequent to storing the web authentication token, employing a media stack that is part of a client browser to initiate playback of media content accessed via a hypertext markup language (HTML) media element; employing the media stack to determine whether the media content is protected; generating, responsive to a determination by the media stack that the media content is protected, a request message requesting a license for playback of the media content; combining the web authentication token into the generated request message by encrypting the web authentication token into the request message, the combining comprising: integrating the web authentication token into the generated request message; and digitally signing the request message having the integrated web authentication token; sending the request message with the encrypted web authentication token to a server; receiving the license for playback of the media content from the server in response to the request message; and sending the received license to the media stack.
 13. The manufacture of claim 12, wherein the web authentication token includes a domain cookie. 